// 采用luch-request封装request网络请求以及请求拦截

import Request from '@/js_sdk/luch-request/luch-request/index.js'
import mHelper from '@/common/helper.js'
import baseConfig from '@/config/config.js'
import store from '@/store';  //全局状态管理（vuex）
import {refreshToken} from '@/api/login';
import mConstData from '@/config/constData.config';
import $constConfig from '@/config/constData.config.js'
import mRoutesConfig from '@/config/routes.config.js';
/* import encryptRequstParams from '@/common/dataFormatOfSign.js';
import qs from 'qs'; */
// 实例化插件对象
const http = new Request()

/**
 * @description 修改全局默认配置
 * @param {Function}   
*/
http.setConfig((config) => { /* config 为默认全局配置*/
    config.baseURL = baseConfig.baseUrl; /* 根域名 */
	// 用户客户端信息
	const systemInfo = uni.getSystemInfoSync();
	const systemInfoHeaders = {
		'device-name': systemInfo.brand, // 设备名称
		'width': systemInfo.screenWidth, // 屏幕宽度
		'height': systemInfo.screenHeight, // 屏幕高度
		'os': systemInfo.platform, // 客户端平台
		'os-version': systemInfo.system // 操作系统版本
	};
	
	

	config.header = {
		...config.header,
		...systemInfoHeaders,
	};
    return config
})

/**
  * 自定义验证器，如果返回true 则进入响应拦截器的响应成功函数(resolve)，否则进入响应拦截器的响应错误函数(reject)
  * @param { Number } statusCode - 请求响应体statusCode（只读）
  * @return { Boolean } 如果为true,则 resolve, 否则 reject
  */
http.validateStatus = (statusCode) => { // 默认
     return statusCode === 200
}


/**
 * @param { Function} cancel - 取消请求,调用cancel 会取消本次请求，但是该函数的catch() 仍会执行; 不会进入响应拦截器
 *
 * @param {String} text ['handle cancel'| any] - catch((err) => {}) err.errMsg === 'handle cancel'。非必传，默认'handle cancel'
 * @cancel {Object} config - catch((err) => {}) err.config === config; 非必传，默认为request拦截器修改之前的config
 * function cancel(text, config) {}
 */
 http.interceptors.request.use((config, cancel) => { 
	
	 /* cancel 为函数，如果调用会取消本次请求。需要注意：调用cancel,本次请求的catch仍会执行。必须return config */
   /* config.header = {
      ...config.header,
      a: 1 // 演示拦截器header加参
    } */
    // 演示custom 用处
    // if (config.custom.auth) {
    //   config.header.token = 'token'
    // }
    // if (config.custom.loading) {
    //  uni.showLoading()
    // }
    /**
    /* 演示cancel 函数
    if (!token) { // 如果token不存在，调用cancel 会取消本次请求，不会进入响应拦截器，但是该函数的catch() 仍会执行
      cancel('token 不存在', config) //  把修改后的config传入，之后响应就可以拿到修改后的config。 如果调用了cancel但是不传修改后的config，则catch((err) => {}) err.config 为request拦截器修改之前的config
    }
    **/
	// config.header['test'] = 'zxf'
	let accessToken = store.state.loginToken //mHelper.getAccessToken()
	// 塞入header中
	// config.header['token'] = accessToken;
	// token存在,塞入data中
	
	if(accessToken){
		config.header['token'] = accessToken;
	}
	
	//加入签名
	
	/* let paramsData = null;
	if(config.method == 'POST'){
		paramsData = config.data
	}else if(config.method == 'GET'){
		paramsData = config.params
	} 
	//console.log(paramsData)
	let signData =  mHelper.getSign(paramsData); */
	

	if(config.method == 'POST'){
		if(!config.header['Content-Type']){
			config.header['Content-Type'] = 'application/x-www-form-urlencoded';
		}
		// config.header['Content-Type'] = 'application/x-www-form-urlencoded';
	}
	
	if(config.data == undefined)
	{
		config.data = [];
	}
	
	//增加一个时间戳
	// config.data['timestamp'] = (new Date()).getTime();
	
	// config.data['nouncestring'] = mHelper.guid();
	
	//判断是否内部调试包
	if(baseConfig.internalSpecial){
		//内部专用
		config.data['iamMaster'] = 1;
	}
	
	/* if(store.getters.hasLogin)
	{
		let loginToken = store.state.loginToken;
		let userInfo = store.state.userInfo;
		
		//传递 登录需要的参数
		config.data['lsid'] = loginToken.lsid || '';
		config.data['sid'] = loginToken.sid || '';
		config.data['phone'] = userInfo.phone || '';
		config.data['deviceId'] = loginToken.deviceId || '';
	} */
	
	//处理签名
	  // let params = qs.parse(config.data); //序列化数据解析qs.parse()将 URL 解析成对象的形式
	  // config.data = encryptRequstParams.encript(params);
	// console.log('处理签名',config,qs.parse(config.data))
	
	//header添加签名校验
	let signData =  mHelper.getSign();
	config.header['sign'] = signData['sign']
	config.header['timeStamp'] = signData['timeStamp']
	config.header['nounceStr'] = signData['nounceStr']
	// console.log('签名11',config.header)
    return config
  })

/**
 * 请求后拦截器
 */
http.interceptors.response.use((response) => { /* 对响应成功做点什么 （statusCode === 200），必须return response*/
  //  if (response.data.code !== 200) { // 服务端返回的状态码不等于200，则reject()
  //    return Promise.reject(response) // return Promise.reject 可使promise状态进入catch
 // if (response.config.custom.verification) { // 演示自定义参数的作用
  //   return response.data
  // }
  // if(response.data.code == 405) //token失效
  // {
	 //  mHelper.toast(response.data.msg)
  // 	  //mHelper.backToLogin();
  // 	  return false;
  // }

   //检查站点状态
	/* if(response.data.code == 5555 && response.data.msg == 'website system maintenance')
	{
		
		  uni.navigateTo({
		       url: mRoutesConfig.systemMaintain.path
		      });
		  return false;
	}

  if(response.data.code == 20001 && response.data.msg == 'User no login.') //token失效
  {
	  mHelper.backToLogin();
	  return false;
  } */
  // console.log('请求响应!!',response.data)
  
  if(response.data.code == 401){
	   console.log('请重新登录',response);
	 mHelper.toast(response.data.msg)
	 setTimeout(function(){
	 		mHelper.backToLogin();
	 },2000);
	 return false;
  }
  if(response.data.code == 403) //账号被禁用或者销户
  {
	  mHelper.toast('账号已被禁用或者销户，请联系客服！')
	  setTimeout(function(){
		   mHelper.backToLogin();
	  },2000)
  	 
  	  return false;
  }
  
	//console.log(response.header)
  // if(response.header && Object.keys(response.header).length > 0 && Object.keys(response.header).indexOf('authorization') !== -1)
  // {
	 //  let token = res.header.authorization.split(" ")[1];
	 //  uni.setStorageSync($constConfig.storeKey.token,token);
  // }
	
  return response.data;
}, (error) => { /*  对响应错误做点什么 （statusCode !== 200），必须return response*/
  console.log('响应错误',error);
  if(error.data.code == 401){
  	   console.log('请重新登录',error);
  	 mHelper.toast(error.data.msg)
  	 setTimeout(function(){
  	 		mHelper.backToLogin();
  	 },1000);
  	
  }
  return Promise.reject(error);
})
  


  
  
export default http